home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1993 / 2 / 02 / devices (folge 4) / condev.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-01  |  12.5 KB  |  474 lines
  1. /* ConDev.c
  2.  
  3.    richtet eine --- Shell --- fuer die Arbeit mit dem
  4.    Console Device ein.
  5.  
  6.    Autor: E.G. Meyzis, Mai 1992
  7.  
  8.    Compile Instr. fuer DICE:
  9.    dcc ConDev.c -c -o t:ConDev.o
  10.  
  11.    Link Instr. fuer DICE:
  12.    dlink dlib:c.o t:ConDev.o dlib:c.lib+
  13.    dlib:amigas20.lib dlib:auto.lib dlib:x.o -o ConDev
  14. */
  15.  
  16. #include <Devices/Console.h>
  17. #include <Devices/ConUnit.h>
  18. #include <Dos/Dos.h>
  19. #include <Exec/Exec.h>
  20. #include <Intuition/Intuition.h>
  21. #include <stdlib.h>
  22. #include <stdio.h>
  23. #include <utility/TagItem.h>
  24.  
  25. /* +++++++++  Definitionen  ++++++++++++
  26. */
  27. #define TRUE      1   /* um mit Datentyp BOOL zu arbeiten */
  28. #define FALSE     0
  29. #define CSI    0x9B /* Control Sequence Introducer, wie z.B.
  30.                        fuer F-Tasten F1 bis F10 verwendet */
  31. #define OS200    36                  /* mindestens OS 2.0 */
  32.  
  33.  
  34. #define ConTitle " Con Dev "    /* Titel Console Window */
  35.  
  36. /* +++++++++  Datentypen  ++++++++++++
  37. */
  38. typedef char                BOOL;
  39. typedef char                *CharPtr;
  40. typedef struct IOStdReq     *IOStdReqPtr;
  41. typedef struct Window       *WindowPtr;
  42. typedef struct MessagePort  *MsgPortPtr;
  43.  
  44.  
  45. /* ++++++++ Routinen des Basisprogramms ++++++++++ */
  46.  
  47. BOOL RunningOS2();
  48. void IORequestAbbauen(IOStdReqPtr reqPtr);
  49. void Aufraeumen();
  50. BOOL FensterAngelegt(WindowPtr *win);
  51. BOOL ConsoleEingerichtet(IOStdReqPtr *wrPtr, *rdPtr,
  52.                                   WindowPtr   winPtr);
  53. BOOL IORequestAngelegt(IOStdReqPtr *conPtr);
  54. void ConWriteStr(IOStdReqPtr conPtr, CharPtr str);
  55. void ConWriteBuf(IOStdReqPtr conPtr,
  56.                  CharPtr     bufPtr,
  57.                  int        laenge);
  58. int ConReadSync(IOStdReqPtr conPtr,
  59.                 CharPtr     bufPtr,
  60.                 int         laenge);
  61. BOOL ConReadASync(IOStdReqPtr conPtr,
  62.                   CharPtr     bufPtr,
  63.                   int         laenge);
  64. void IDCMPCloseClickAbholen(WindowPtr winPtr);
  65.  
  66. /* ++++++++  Demo- und Test-Routinen ++++++++++ */
  67.  
  68. void SchreibTest();
  69. void LeseTest();
  70. void LeseRawEvent();
  71. void EventCloseClickAbholen(IOStdReqPtr conPtr);
  72. void ANSICodeDemo();
  73.  
  74.  
  75. /* +++++++++  globale Variablen  ++++++++++++
  76. */
  77. WindowPtr       ourWinPtr;
  78.  
  79. /* Ein Device, zwei I/O Strukturen */
  80.  
  81. IOStdReqPtr     conWritePtr, /* Schreiben */
  82.                 conReadPtr;  /* Lesen */
  83.  
  84.  
  85. int main()
  86. {
  87.   int returnVal = 0; /* erfolgreiche Ausfuehrung annehmen */
  88.  
  89.   if (RunningOS2())   /* dann haben wir mindestens OS 2.0 */
  90.     {
  91.      if(FensterAngelegt(&ourWinPtr))
  92.        {
  93.         if (ConsoleEingerichtet (&conWritePtr,
  94.                                  &conReadPtr, ourWinPtr))
  95.           {
  96.            SchreibTest();
  97.            ANSICodeDemo();
  98.  
  99.            LeseTest();
  100.            LeseRawEvent();
  101.  
  102.            IDCMPCloseClickAbholen(ourWinPtr);  /*  warten */
  103.           }
  104.         else
  105.           returnVal = 10;  /* Console Dev. nicht anlegbar */
  106.        }                         /* Fenster ... */
  107.      else
  108.        returnVal = 11;           /* Window nicht anlegbar */
  109.      Aufraeumen();
  110.     }                            /* Running ... */
  111.   else
  112.     returnVal = 12;                         /* OS 1.2/1.3 */
  113.  
  114.   return returnVal;
  115. }
  116.  
  117.  
  118. BOOL RunningOS2()        /* lauft Programm unter OS 2.x ? */
  119. {
  120.   long            *systemBasis;
  121.   struct ExecBase *execBasePtr;
  122.  
  123.   systemBasis = (APTR)4;  /* Adr ExecBase a. Adr. 4 holen */
  124.   execBasePtr = (APTR)*systemBasis;
  125.   if (execBasePtr->LibNode.lib_Version >= OS200) /* OS 2  */
  126.      return TRUE;
  127.   else
  128.      return FALSE;
  129. }
  130.  
  131.  
  132. void Aufraeumen()                 /* Ressourcen freigeben */
  133. {
  134.   if (conReadPtr)                   /* Lese- I/O Struktur */
  135.     {
  136.      if (!CheckIO(conReadPtr))    /* laeuft ein I/O Req.? */
  137.        {
  138.         AbortIO(conReadPtr); /* falls ja, diesen abbrechen*/
  139.         WaitIO(conReadPtr);  /* und auf Beendigung warten */
  140.        }
  141.      IORequestAbbauen(conReadPtr);   /* einschl. Msg Port */
  142.     }
  143.   if (conWritePtr)
  144.     {
  145.      if (conWritePtr->io_Device)
  146.        CloseDevice(conWritePtr);
  147.      IORequestAbbauen(conWritePtr);
  148.     }
  149.   if (ourWinPtr)
  150.     {
  151.      CloseWindow(ourWinPtr);
  152.      ourWinPtr = 0;
  153.     }
  154. }
  155.  
  156.  
  157. void IORequestAbbauen(IOStdReqPtr reqPtr)
  158.  
  159. {
  160.   if (reqPtr->io_Message.mn_ReplyPort)
  161.     {                                             /* OS 2 */
  162.      DeleteMsgPort(reqPtr->io_Message.mn_ReplyPort);
  163.   }
  164.   DeleteIORequest(reqPtr);                        /* OS 2 */
  165.   reqPtr = 0;
  166. }
  167.  
  168.  
  169. BOOL FensterAngelegt(WindowPtr *win)
  170.  
  171. {
  172.   static struct TagItem tagBuffer[10] =           /* OS 2 */
  173.                    {
  174.                     WA_Left,      20,
  175.   /* DICE ver- */   WA_Top,       20,
  176.   /* langt es, */   WA_Title,    (ULONG*) ConTitle,
  177.   /* die Struk-*/   WA_Width,    500,
  178.   /* tur, glo- */   WA_Height,   200,
  179.   /* bal oder  */   WA_MinWidth, 100,
  180.   /* static an */   WA_MinHeight, 50,
  181.   /* zulegen   */   WA_Flags,  WFLG_SIMPLE_REFRESH |
  182.                                WFLG_CLOSEGADGET |
  183.                                WFLG_DEPTHGADGET |
  184.                                WFLG_DRAGBAR  |
  185.                                WFLG_SIZEGADGET,
  186.                     TAG_DONE
  187.                    };
  188.  
  189.   *win = (WindowPtr)OpenWindowTagList (NULL, tagBuffer);
  190.   return (*win != NULL);
  191. }
  192.  
  193.  
  194. BOOL ConsoleEingerichtet(IOStdReqPtr *wrPtr, *rdPtr,
  195.                                   WindowPtr   winPtr)
  196.  
  197. {
  198.   IOStdReqPtr writePtr,
  199.               readPtr;
  200.   BOOL done = FALSE;
  201.  
  202.   if (IORequestAngelegt(&writePtr))    /* 1. I/O struktur */
  203.     {
  204.      writePtr->io_Data = winPtr;      /* Intuition Window */
  205.      writePtr->io_Length = sizeof(struct Window);
  206.      OpenDevice("console.device", CONU_STANDARD,  /* OS 2 */
  207.                  writePtr, CONFLAG_DEFAULT);
  208.      if ((!writePtr->io_Error) &&     /* Device geoeffnet */
  209.                               (IORequestAngelegt(&readPtr)))
  210.        {
  211.         readPtr->io_Unit = writePtr->io_Unit; /* 2. Strukt*/
  212.         readPtr->io_Device = writePtr->io_Device; /* erbt */
  213.         done = TRUE;
  214.         *wrPtr = writePtr;   /* Zeiger auf I/O Strukturen */
  215.         *rdPtr = readPtr;    /* ans rufende Prog. geben */
  216.        }
  217.      else
  218.        Aufraeumen;                 /* mangelte es an RAM? */
  219.     }
  220.   return done;
  221. }
  222.  
  223. BOOL IORequestAngelegt(IOStdReqPtr *conPtr)
  224.  
  225. {
  226.   MsgPortPtr portPtr;
  227.   BOOL       done = FALSE;
  228.  
  229.   portPtr = (MsgPortPtr)CreateMsgPort();           /* OS2 */
  230.   if (portPtr)
  231.     {
  232.      *conPtr = (IOStdReqPtr)
  233.               CreateIORequest(portPtr,            /* OS 2 */
  234.                               sizeof(struct IOStdReq));
  235.      if (*conPtr)
  236.        done = TRUE;
  237.      else
  238.        DeleteMsgPort(portPtr);                    /* OS 2 */
  239.     }
  240.   return done;
  241. }
  242.  
  243.  
  244. void ConWriteStr(IOStdReqPtr conPtr, CharPtr str)
  245. {
  246.   conPtr->io_Data = str;
  247.   conPtr->io_Length = -1; /* nur f. mit 0 termin. Strings */
  248.   conPtr->io_Command = CMD_WRITE;
  249.   DoIO(conPtr);
  250. }
  251.  
  252.  
  253. void ConWriteBuf(IOStdReqPtr conPtr,
  254.                  CharPtr     bufPtr, /*m. auszugeb. Zeich.*/
  255.                  int        laenge)      /* Zeichenanzahl */
  256. {
  257.   conPtr->io_Data = bufPtr;
  258.   conPtr->io_Length = laenge;         /* beliebige Laenge */
  259.   conPtr->io_Command = CMD_WRITE;
  260.   DoIO(conPtr);
  261. }
  262.  
  263.  
  264. int ConReadSync(IOStdReqPtr conPtr,
  265.                 CharPtr     bufPtr,     /* dort hin lesen */
  266.                 int         laenge) /* Anzahl der Zeichen */
  267. {
  268.   conPtr->io_Data = bufPtr;
  269.   conPtr->io_Length = laenge;
  270.   conPtr->io_Command = CMD_READ;
  271.   SendIO(conPtr);
  272.   WaitIO(conPtr);                /* nur unter OS 2 sicher */
  273.   return conPtr->io_Actual;
  274. }
  275.  
  276.  
  277. BOOL ConReadASync(IOStdReqPtr conPtr, /*asynchrones Lesen */
  278.                   CharPtr     bufPtr, /* ist das empfohle-*/
  279.                   int         laenge) /*ne Verfahren */
  280. {
  281.   conPtr->io_Data = bufPtr;
  282.   conPtr->io_Length = laenge;
  283.   conPtr->io_Command = CMD_READ;
  284.   SendIO(conPtr);    /* bewirkt o. WaitIO  Asynchronitaet */
  285. }
  286.  
  287.  
  288.  
  289. void IDCMPCloseClickAbholen(WindowPtr winPtr)
  290.  
  291. {
  292.   ModifyIDCMP(winPtr, IDCMP_CLOSEWINDOW);/*UserPort einr. */
  293.   WaitPort(winPtr->UserPort);
  294.   ReplyMsg(GetMsg(winPtr->UserPort));
  295. }
  296.  
  297. void SchreibTest()  /* Schreibfarbe waehlen u. Textumbruch*/
  298.                     /* sowie Scrolling zeigen */
  299. {
  300.   int  zaehler;
  301.  
  302.   ConWriteStr(conWritePtr,
  303.                   "\033[1;31mHallo Console! ");
  304. /*                 ^   ^^ ^ ^
  305.                    |   || | 0x6D = Terminator
  306.                    |   || rot
  307.                    |   |bold
  308.                    |   0x5B \
  309.                    ESC      / Ersatz fuer CSI
  310. */
  311.   for (zaehler = 0; zaehler < 100; zaehler++)
  312.    {
  313.     ConWriteStr(conWritePtr,       /* bold + Farbe bleibt */
  314.                 "Hallo Console! ");
  315.   }
  316. }
  317.  
  318. void LeseTest()
  319. {
  320.   char buffer[10];
  321.   int  laenge;
  322.  
  323.   ConWriteStr(conWritePtr,
  324.               "\n\033[3;35m** Geben Sie 1 Zeichen ein ** ");
  325. /*                ^  ^^ ^ ^
  326.                   |  || | 0x6D = Terminator
  327.                   |  || violett
  328.                   |  |italic
  329.                   |  0x5B
  330.                   ESC
  331. */
  332.   laenge = ConReadSync(conReadPtr, buffer, sizeof(buffer));
  333.   if (buffer[0] == (char)CSI)
  334.     {
  335.      buffer[0] = '@'; /* CSI kann nicht ausgegeben werden */
  336.     }
  337.   ConWriteBuf(conWritePtr, buffer, laenge);
  338. }
  339.  
  340. void LeseRawEvent()  /* spezialisiert auf Keyboard Events */
  341.  
  342. {
  343.   char buffer[400];       /* Je nach Delay dimensionieren */
  344.   int  index,
  345.        laenge;
  346.  
  347.   ConWriteStr(conWritePtr,
  348.    "\033[0;31m\n\n\033[1{cl;scl;key;qual;p1;p2;sec;mic|\n");
  349. /*                 ^   ^^
  350.                    |   |Terminator Raw-Event Anforderung
  351.                    |   RAW-Keyboard Input
  352.                    ESC
  353. */
  354.   Delay(100);/*um mit Tastatur dev.-int. Puffer zu fuellen*/
  355.  
  356.   laenge = ConReadSync(conReadPtr, buffer, sizeof(buffer));
  357.  
  358.   for (index = 0; index < laenge; index++)
  359.     {
  360.      if (buffer[index] == (char)CSI)
  361.         buffer[index] = (char)012;    /* neue Zeile bitte */
  362.     }                                 /* anstelle des CSI */
  363.   ConWriteBuf(conWritePtr, buffer, laenge); /* alle Zeilen*/
  364. }
  365.  
  366.  
  367. void EventCloseClickAbholen(IOStdReqPtr conPtr)
  368.  
  369. { char closeEvent[40];
  370.   BOOL  waitClose = TRUE;
  371.  
  372.   ConWriteStr(conPtr, "\033[1;15}");
  373. /*                          ^ ^ ^
  374.                             | | stop reporting events
  375.                             | disk removed
  376.                             raw keyboard inputs
  377. */
  378.   ConWriteStr(conPtr, "\033[11{ \nClick CloseGadget\n");
  379. /*                          ^ ^
  380.                             | start reporting
  381.                             Close Gadget Event
  382. */
  383.   do
  384.     {
  385.      ConReadSync(conPtr, closeEvent, sizeof(closeEvent));
  386.      if ((closeEvent[1] == '1') && (closeEvent[2] == '1'))
  387.        waitClose = FALSE;
  388.     }
  389.   while (waitClose);
  390. }
  391.  
  392. char TwoCharToNum(const char *charPtr)
  393. {
  394.  return (charPtr[0] -48) * 10 + (charPtr[1] - 48);
  395. }
  396.  
  397.  
  398. void FensterGroesse(char *zeilen, char *spalten)
  399. {
  400.   char  puffer[20];
  401.   int   laenge;
  402.  
  403.   ConWriteStr(conWritePtr, "\033[0 q\n"); /*Status Request*/
  404.   laenge = ConReadSync        /* Fenstergroesse empfangen */
  405.            (conReadPtr, puffer, sizeof(puffer));
  406.   *zeilen = TwoCharToNum(&puffer[5]);/* Zeilenanzahl holen */
  407.   *spalten = TwoCharToNum(&puffer[8]);/* Spaltenanz. holen */
  408.  
  409. }
  410.  
  411. void NumToTwoChar(const char *charPtr, char number)
  412. {
  413.   charPtr[0] = (char)number / 10 + 48;
  414.   charPtr[1] = (char)number % 10 + 48; /* Divisions Rest */
  415. }
  416.  
  417.  
  418. void CursorSetzen(char xPos, yPos)
  419. {
  420.   char puffer[15];
  421.  
  422.   strcpy(puffer, "\033[00;00H", 11);   /* CursPos Huelse */
  423. /*                     ^  ^
  424.                        |  5. Byte
  425.                        2. Byte
  426. */
  427.   NumToTwoChar(&puffer[2], yPos); /* Bytes 2 + 3 ersetzen */
  428.   NumToTwoChar(&puffer[5], xPos); /* Bytes 5 + 6 ersetzen */
  429.  
  430.   ConWriteStr(conWritePtr, puffer); /* Cursor positionier.*/
  431. }
  432.  
  433.  
  434. void ANSICodeDemo()
  435. {
  436.   char  cursorReport[10];
  437.   char  horiz,
  438.         vert;
  439.   int   laenge;
  440.  
  441.   ConWriteStr(conWritePtr, "\033[6n\n"); /* Status Report */
  442.   laenge = ConReadSync                /* Report empfangen */
  443.            (conReadPtr, cursorReport, sizeof(cursorReport));
  444.  
  445.   /* Report umsetzen in Cursor Positionierungs-Befehl */
  446.   cursorReport[laenge - 1] = 'H';
  447.   cursorReport[laenge] = (char)0;  /* in String umwandeln */
  448.  
  449.   FensterGroesse(&vert, &horiz);
  450.  
  451.   ConWriteStr(conWritePtr, "\033[3;34;47m"); /*blau/weiss */
  452.  
  453.   CursorSetzen(horiz / 2 - 6, vert / 2 - 1);
  454.   ConWriteStr(conWritePtr, "           ");
  455.  
  456.   ConWriteStr(conWritePtr, "\033[1B");/*Cursor 1 line down*/
  457.   ConWriteStr(conWritePtr, "\033[11D");  /*11 links bitte */
  458.   ConWriteStr(conWritePtr, "   AMIGA   ");
  459.  
  460.   ConWriteStr(conWritePtr, "\033[1B");/*Cursor 1 line down*/
  461.   ConWriteStr(conWritePtr, "\033[11D");  /* Cursor 11 left*/
  462.   ConWriteStr(conWritePtr, "           ");
  463.  
  464.   /* vor und zurueck scrollen */
  465.  
  466.   ConWriteStr(conWritePtr, "\033[2T");
  467.   ConWriteStr(conWritePtr, "\033[4S");
  468.   ConWriteStr(conWritePtr, "\033[2T");
  469.  
  470. /* Cursor-Report modifiziert zurueckschreiben, um Cursor zu
  471.    setzen, wo er anfangs war */
  472.   ConWriteStr(conWritePtr,cursorReport);
  473. }
  474.